home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / machserver / 1.098 / Include / ofs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1991-05-08  |  19.2 KB  |  508 lines
  1. /*
  2.  * ofs.h --
  3.  *
  4.  *    Definitions related to the storage of the original Sprite filesystem
  5.  *    on a disk.
  6.  *
  7.  * Copyright 1986 Regents of the University of California
  8.  * All rights reserved.
  9.  *
  10.  *
  11.  * $Header: /sprite/src/kernel/ofs/RCS/ofs.h,v 1.3 90/10/19 15:52:26 mendel Exp $ SPRITE (Berkeley)
  12.  */
  13.  
  14. #ifndef _OFS
  15. #define _OFS
  16.  
  17. #ifdef KERNEL
  18. #include <dev.h>
  19. #include <fslcl.h>
  20. #include <fsioFile.h>
  21. #include <fsdm.h>
  22. #include <devBlockDevice.h>
  23. #else
  24. #include <kernel/dev.h>
  25. #include <kernel/fslcl.h>
  26. #include <kernel/fsdm.h>
  27. #include <kernel/devBlockDevice.h>
  28. #endif
  29.  
  30. /*
  31.  * ONE sector of summary information is kept on disk.  This records things
  32.  * like the number of free blocks and free file descriptors.  This info
  33.  * is located just before the domain header.
  34.  */
  35. #define OFS_SUMMARY_PREFIX_LENGTH    64
  36. typedef struct Ofs_SummaryInfo {
  37.     int        numFreeKbytes;        /* Free space in kbytes, not blocks */
  38.     int        numFreeFileDesc;    /* Number of free file descriptors */
  39.     int        state;            /* Unused. */
  40.     char    domainPrefix[OFS_SUMMARY_PREFIX_LENGTH];
  41.                     /* Last prefix used for the domain */
  42.     int        domainNumber;        /* The domain number of the domain
  43.                      * under which this file system was
  44.                      * last mounted. */
  45.     int        flags;            /* Flags defined below. */
  46.     int        attachSeconds;        /* Time the disk was attached */
  47.     int        detachSeconds;        /* Time the disk was off-lined.  This
  48.                      * is the Fsutil_TimeInSeconds that the
  49.                      * system was shutdown or the disk
  50.                      * was detached.  If the domain is
  51.                      * marked NOT_SAFE then this field
  52.                      * is undefined, but attachTime is ok
  53.                      * as long as TIMES_VALID is set. */
  54.     int        fixCount;        /* Number of consecutive times that 
  55.                      * fscheck has found an error in this
  56.                      * domain. Used to prevent infinite
  57.                      * looping.
  58.                      */
  59.  
  60.     char pad[DEV_BYTES_PER_SECTOR -
  61.          (8 * sizeof(int) + OFS_SUMMARY_PREFIX_LENGTH)];
  62. } Ofs_SummaryInfo;
  63.  
  64. /*
  65.  * Flags for summary info structure.
  66.  *    OFS_DOMAIN_NOT_SAFE    Set during normal operation. This is unset
  67.  *        when we know we    are shutting down cleanly and the data
  68.  *        structures on the disk partition (domain) are ok.
  69.  *    OFS_DOMAIN_ATTACHED_CLEAN    Set if the initial attach found the
  70.  *        disk marked 'safe'
  71.  *    OFS_DOMAIN_TIMES_VALID    If set then the attach/detachSeconds fields
  72.  *        are valid.
  73.  *    OFS_DOMAIN_JUST_CHECKED Set if the disk was just checked by fscheck
  74.  *        and doesn't need to be rechecked upon reboot.  This is only
  75.  *        useful for the root partition, since that is the only one
  76.  *        that requires a reboot.  In theory only the 
  77.  *        OFS_DOMAIN_NOT_SAFE should be needed, but we don't yet
  78.  *        trust the filesystem to shut down cleanly.
  79.  */
  80. #define    OFS_DOMAIN_NOT_SAFE        0x1
  81. #define OFS_DOMAIN_ATTACHED_CLEAN    0x2
  82. #define    OFS_DOMAIN_TIMES_VALID        0x4
  83. #define OFS_DOMAIN_JUST_CHECKED    0x8
  84.  
  85. /*
  86.  * Stuff for block allocation 
  87.  */
  88.  
  89. #define    OFS_NUM_FRAG_SIZES    3
  90.  
  91. /*
  92.  * The bad block file, the root directory of a domain and the lost and found 
  93.  * directory have well known file numbers.
  94.  */
  95. #define OFS_BAD_BLOCK_FILE_NUMBER    FSDM_BAD_BLOCK_FILE_NUMBER
  96. #define OFS_ROOT_FILE_NUMBER        FSDM_ROOT_FILE_NUMBER
  97. #define OFS_LOST_FOUND_FILE_NUMBER    FSDM_LOST_FOUND_FILE_NUMBER
  98.  
  99. /*
  100.  * The lost and found directory is preallocated and is of a fixed size. Define
  101.  * its size in 4K blocks here.
  102.  */
  103. #define    OFS_NUM_LOST_FOUND_BLOCKS    2
  104.  
  105. /*
  106.  * Structure to keep statistics about each cylinder.
  107.  */
  108.  
  109. typedef struct OfsCylinder {
  110.     int    blocksFree;    /* Number of blocks free in this cylinder. */
  111. } OfsCylinder;
  112.  
  113.  
  114.  
  115. /*
  116.  * The geometry of a disk is a parameter to the disk block allocation routine.
  117.  * It is stored in disk in the Domain header so that different configurations
  118.  * on the same disk can be tried out and compared.
  119.  *
  120.  * The following parameters define array sizes in the Ofs_Geometry struct.
  121.  *
  122.  * OFS_MAX_ROT_POSITIONS defines how many different rotational positions are
  123.  * possible for a filesystem block.  An Eagle Drive, for example, has 23
  124.  * rotational positions.  There are 46 sectors per track.  That means that
  125.  * 5 4K filesystem blocks fit on a track and the 6th spills over onto the
  126.  * next track.  This offsets all the 4K blocks on the next track by 1K.
  127.  * This continues for 4 tracks after which 23 whole blocks have been
  128.  * packed in.  The set of 23 blocks is called a ``rotational set''.
  129.  * Also, because the Eagle has 20 heads, and each rotational set occupies
  130.  * 4 tracks, there are 5 rotational sets per cylinder.
  131.  *
  132.  * OFS_MAX_TRACKS_PER_SET defines how many tracks a rotational set can
  133.  * take up.
  134.  */
  135. #define OFS_MAX_ROT_POSITIONS    32
  136. #define OFS_MAX_TRACKS_PER_SET    10
  137.  
  138. /*
  139.  * There is a new mapping available for SCSI disks.  In this mapping we
  140.  * ignore rotational sets altogether and pack as many blocks as possible
  141.  * into a cylinder. The field rotSetsPerCyl is overloaded to allow us
  142.  * to be backwards compatible. If rotSetsPerCyl == OFS_SCSI_MAPPING
  143.  * then we are using the new mapping.  The other fields relating to
  144.  * rotational sets and block offsets are ignored.
  145.  */
  146.  
  147. #define OFS_SCSI_MAPPING -1
  148.  
  149. typedef struct Ofs_Geometry {
  150.     /*
  151.      * Fundamental disk geometry that cannot be varied.
  152.      */
  153.     int        sectorsPerTrack;/* The number of sectors per track */
  154.     int        numHeads;    /* The number of surfaces on the disk */
  155.     /*
  156.      * Filesystem blocks take up several disk sectors, and filesystem
  157.      * blocks on different surfaces may be skewed relative to each other
  158.      * because a whole number of filesystem blocks generally does not fit
  159.      * on one track.  (This property is exploited when looking for blocks
  160.      * that are rotationaly optimal with respect to each other.)  The
  161.      * skewing pattern is repeated after a certain number of filesystem
  162.      * blocks.  The pattern is contrained to fit on a whole number of
  163.      * tracks, and a whole number of the patterns has to fit in one
  164.      * cylinder.  This means that there may be unused sectors at the end
  165.      * of each set of filesystem blocks.
  166.      */
  167.     int        blocksPerRotSet;    /* The number of distinct rotational
  168.                      * positions for filesystem blocks */
  169.     int        tracksPerRotSet;    /* The number of disk tracks taken
  170.                      * up by a rotational set.  Used to
  171.                      * bounce from one set to another
  172.                      * and to map from filesystem block
  173.                      * indexes to disk sectors */
  174.     int        rotSetsPerCyl;        /* The number of rotational sets in a
  175.                      * cylinder.  There are numRotPositions
  176.                      * filesystem blocks in each set */
  177.     int        blocksPerCylinder;    /* This is the product of blocksPerSet
  178.                      * and numRotationSets */
  179.     /*
  180.      * The following diagram shows a rotational set for a disk with 46
  181.      * 512 byte sectors per track.  8 disk sectors are needed for each
  182.      * filesystem block, and this allows 5 3/4 blocks per trask.
  183.      * This means that 23 filesystem blocks make up a rotational set
  184.      * that occupies 4 tracks.
  185.     ----------------------------------------------------
  186.     |..1.....|..2.....|..3.....|..4.....|..5.....|..6...    track 1
  187.     ----------------------------------------------------
  188.     ..|..7.....|..8.....|..9.....|..10....|..11....|..12    track 2
  189.     ----------------------------------------------------
  190.     ....|..13....|..14....|..15....|..16....|..17....|..    track 3
  191.     ----------------------------------------------------
  192.     .18...|..19....|..20....|..21....|..22....|..23....|    track 4
  193.     ----------------------------------------------------
  194.      * In order to facilitate rotationally optimal allocation the
  195.      * rotational positions are sorted by increasing offset.  In the
  196.      * above example, the sorted ordering is (1, 7, 13, 19, 2, 8...)
  197.      */
  198.     int        blockOffset[OFS_MAX_ROT_POSITIONS];    /* This keeps the
  199.                      * starting sector number for each
  200.                      * rotational position.  This table
  201.                      * is computed by the makeFilesystem
  202.                      * user program */
  203.     int        sortedOffsets[OFS_MAX_ROT_POSITIONS];    /* An ordered set of
  204.                      * the rotational positions */
  205.     /*
  206.      * Add more data after here so we have to reformat the disk less often.
  207.      */
  208. } Ofs_Geometry;
  209.  
  210.  
  211. /*
  212.  * A disk is partitioned into areas that each store a domain.  Each domain
  213.  * contains a DomainHeader that describes how the blocks of the domain are
  214.  * used.  The layout information takes into account the blocks that are
  215.  * reserved for the copy of the Disk Header and the boot program.
  216.  */
  217. typedef struct Ofs_DomainHeader {
  218.     unsigned int magic;        /* magic number for consistency check */
  219.     int        firstCylinder;    /* Disk relative number of the first cylinder
  220.                  * in the domain.  This is redundant with
  221.                  * respect to the complete partition map
  222.                  * kept in the Disk Header */
  223.     int        numCylinders;    /* The number of cylinders in the domain.
  224.                  * Also redundant with Disk Header */
  225.     Fs_Device    device;        /* Device identifier of the domain passed to
  226.                  * the device driver block IO routines.
  227.                  * Two fields are valid on disk: the serverID
  228.                  * records the rpc_SpriteID of the server,
  229.                  * and the unit number indicates which partition
  230.                  * in the superblock this header corresponds
  231.                  * to.  This is needed because more than one
  232.                  * partition can start at the same spot on
  233.                  * disk (of course, only one is valid to use).
  234.                  * The device type on disk is ignored */
  235.     /*
  236.      * An array of FsDescriptors is kept on the disk and an accompanying
  237.      * bitmap is used to keep track of free and allocated file descriptors.
  238.      */
  239.     int        fdBitmapOffset;    /* The block offset of the bitmap used to
  240.                  * keep track of free FileDescriptors */
  241.     int        fdBitmapBlocks;    /* The number of blocks in the bitmap */
  242.     int        fileDescOffset;    /* The block offset of the array of fds.
  243.                  * The number of blocks in the array comes
  244.                  * from numFileDesc */
  245.     int        numFileDesc;    /* The number of FsDescriptors in the domain.
  246.                  * This is an upper limit on the number of
  247.                  * files that be kept in the domain */ 
  248.     /*
  249.      * A large bitmap is used to record the status of all the data blocks
  250.      * in the domain.
  251.      */
  252.     int        bitmapOffset;    /* The block number of the start of bitmap */
  253.     int        bitmapBlocks;    /* Number of blocks used to store bitmap */
  254.     /*
  255.      * The data blocks take up the rest of the domain.
  256.      */
  257.     int        dataOffset;    /* The block number of the start of data */
  258.     int        dataBlocks;    /* Number of data blocks */
  259.     int        dataCylinders;    /* Number of cylinders containing data blocks */
  260.     /*
  261.      * Disk geometery parameters are used map from block indexes to
  262.      * disk sectors, and also to optimally allocate blocks.
  263.      */
  264.     Ofs_Geometry    geometry;    /* Used by the allocation routines and
  265.                      * by the block IO routines */
  266. } Ofs_DomainHeader;
  267.  
  268. #define OFS_DOMAIN_MAGIC    (unsigned int)0xF8E7D6C5
  269.  
  270. /*
  271.  * OFS_NUM_DOMAIN_SECTORS is the standard number of sectors taken
  272.  * up by the domain header.
  273.  */
  274. #define OFS_NUM_DOMAIN_SECTORS    ((sizeof(Ofs_DomainHeader)-1) / DEV_BYTES_PER_SECTOR + 1)
  275.  
  276. #ifdef KERNEL
  277. /*
  278.  * Structure for each domain.
  279.  */
  280.  
  281. typedef struct Ofs_Domain {
  282.     Fsio_FileIOHandle    physHandle;    /* Handle to use to read and write
  283.                      * physical blocks. */
  284.     Ofs_DomainHeader *headerPtr;     /* Disk information for the domain. */
  285.     /*
  286.      * Disk summary information.
  287.      */
  288.     Ofs_SummaryInfo *summaryInfoPtr;
  289.     int          summarySector;
  290.     /*
  291.      * Data block allocation.
  292.      */
  293.     unsigned char *dataBlockBitmap;    /* The per domain data block bit map.*/
  294.     int        bytesPerCylinder;    /* The number of bytes in the bit map
  295.                      * for each cylinder. */
  296.     OfsCylinder    *cylinders;        /* Pointer to array of cylinder
  297.                      * information. */
  298.     List_Links    *fragLists[OFS_NUM_FRAG_SIZES];    /* Lists of fragments. */
  299.     Sync_Lock    dataBlockLock;        /* Lock for data block allocation. */
  300.     int        minKFree;        /* The minimum number of kbytes that 
  301.                      * must be free at all times. */
  302.     /*
  303.      * File descriptor allocation.
  304.      */
  305.     unsigned char *fileDescBitmap;    /* The per domain file descriptor bit
  306.                      * map.*/
  307.     Sync_Lock    fileDescLock;        /* Lock for file descriptor
  308.                      * allocation. */
  309.     Fsdm_Domain *domainPtr;        /* Domain of this file system. */
  310.     DevBlockDeviceHandle *blockDevHandlePtr; /* Block device containing file
  311.                           * system. */
  312. } Ofs_Domain;
  313.  
  314. /*
  315.  * Types of indexing.  Order is important here because the indirect and
  316.  * double indirect types can be used to index into the indirect block 
  317.  * pointers in the file descriptor.
  318.  */
  319.  
  320. #define    OFS_INDIRECT        FSDM_INDIRECT
  321. #define    OFS_DBL_INDIRECT    FSDM_DBL_INDIRECT
  322. #define    OFS_DIRECT        FSDM_DIRECT
  323.  
  324. typedef    int    OfsBlockIndexType;
  325.  
  326. /*
  327.  * Structure to keep information about the indirect and doubly indirect
  328.  * blocks used in indexing.
  329.  */
  330.  
  331. typedef struct OfsIndirectInfo {
  332.         Fscache_Block     *blockPtr;    /* Pointer to indirect block. */
  333.         int        index;        /* An index into the indirect block. */
  334.         Boolean         blockDirty;    /* TRUE if the block has been
  335.                        modified. */
  336.         int         deleteBlock;    /* FSCACHE_DELETE_BLOCK bit set if should 
  337.                        delete the block when are
  338.                        done with it. */
  339. } OfsIndirectInfo;
  340.  
  341. /*
  342.  * Structure used when going through the indexing structure of a file.
  343.  */
  344.  
  345. typedef struct OfsBlockIndexInfo {
  346.     OfsBlockIndexType     indexType;    /* Whether chasing direct, indirect,
  347.                        or doubly indirect blocks. */
  348.     int        blockNum;        /* Block that is being read, written,
  349.                        or allocated. */
  350.     int        lastDiskBlock;        /* The disk block for the last file
  351.                        block. */
  352.     int        *blockAddrPtr;        /* Pointer to pointer to block. */
  353.     int        directIndex;        /* Index into direct block pointers. */
  354.     OfsIndirectInfo indInfo[2];    /* Used to keep track of the two 
  355.                        indirect blocks. */
  356.     int         flags;            /* Flags defined below. */
  357.     Ofs_Domain    *ofsPtr;        /* Domain that the file is in. */
  358. } OfsBlockIndexInfo;
  359.  
  360. /*
  361.  * Structure to keep information about each fragment.
  362.  */
  363.  
  364. typedef struct OfsFragment {
  365.     List_Links  links;          /* Links to put in list of free fragments of
  366.                                    this size. */
  367.     int         blockNum;       /* Block that this fragment comes from. */
  368. } OfsFragment;
  369.  
  370. /*
  371.  * Flags for the index structure.
  372.  *
  373.  *     OFS_ALLOC_INDIRECT_BLOCKS        If an indirect is not allocated then
  374.  *                    allocate it.
  375.  *     OFS_DELETE_INDIRECT_BLOCKS    After are finished with an indirect
  376.  *                    block if it is empty delete it.
  377.  *     OFS_DELETING_FROM_FRONT        Are deleting blocks from the front
  378.  *                    of the file.
  379.  *     OFS_DELETE_EVERYTHING        The file is being truncated to length
  380.  *                    0 so delete all blocks and indirect
  381.  *                    blocks.
  382.  *    FSCACHE_DONT_BLOCK        Don't block on a full cache.  The cache
  383.  *                    can get so full of dirty blocks it can
  384.  *                    prevent the fetching of needed indirect
  385.  *                    blocks.  Our caller can deal with this
  386.  *                    if it sets FSCACHE_DONT_BLOCK, otherwise
  387.  *                    we'll wait for a free cache block.
  388.  *                    (FSCACHE_DONT_BLOCK value is used as
  389.  *                     a convenience - it gets passed to
  390.  *                     Fscache_FetchBlock)
  391.  */
  392.  
  393. #define    OFS_ALLOC_INDIRECT_BLOCKS    0x01
  394. #define    OFS_DELETE_INDIRECT_BLOCKS    0x02
  395. #define    OFS_DELETING_FROM_FRONT    0x04
  396. #define    OFS_DELETE_EVERYTHING        0x08
  397. /*resrv FSCACHE_DONT_BLOCK        0x40000 */
  398.  
  399. /*
  400.  * OFS_PTR_FROM_DOMAIN retrieve the Ofs_Domain pointer from the Fsdm_Domain.
  401.  */
  402. #define    OFS_PTR_FROM_DOMAIN(domainPtr)    ((Ofs_Domain *)(domainPtr->clientData))
  403.  
  404. /*
  405.  * Declarations for the file descriptor allocation routines.
  406.  */
  407.  
  408. extern ReturnStatus Ofs_FileDescInit _ARGS_((Fsdm_Domain *domainPtr, 
  409.         int fileNumber, int type, int permissions, int uid, int gid, 
  410.         Fsdm_FileDescriptor *fileDescPtr));
  411. extern ReturnStatus Ofs_FileDescFetch _ARGS_((Fsdm_Domain *domainPtr, 
  412.         int fileNumber, Fsdm_FileDescriptor *fileDescPtr));
  413. extern ReturnStatus Ofs_FileDescStore _ARGS_((Fsdm_Domain *domainPtr, 
  414.         Fsio_FileIOHandle *handlePtr, int fileNumber, 
  415.         Fsdm_FileDescriptor *fileDescPtr, Boolean forceOut));
  416. extern ReturnStatus Ofs_GetNewFileNumber _ARGS_((Fsdm_Domain *domainPtr, 
  417.         int dirFileNum, int *fileNumberPtr));
  418. extern ReturnStatus Ofs_FreeFileNumber _ARGS_((Fsdm_Domain *domainPtr, 
  419.         int fileNumber));
  420. extern ReturnStatus Ofs_FileTrunc _ARGS_((Fsdm_Domain *domainPtr, 
  421.         Fsio_FileIOHandle *handlePtr, int size, Boolean delete));
  422. /*
  423.  * File index routines. 
  424.  */
  425. extern ReturnStatus OfsGetFirstIndex _ARGS_((Ofs_Domain *ofsPtr,
  426.         Fsio_FileIOHandle *handlePtr, int blockNum, 
  427.         OfsBlockIndexInfo *indexInfoPtr, int flags));
  428.  
  429.  
  430. extern ReturnStatus OfsGetNextIndex _ARGS_((Fsio_FileIOHandle *handlePtr, 
  431.         OfsBlockIndexInfo *indexInfoPtr, Boolean dirty));
  432. extern void OfsEndIndex _ARGS_((Fsio_FileIOHandle *handlePtr, 
  433.         OfsBlockIndexInfo *indexInfoPtr, Boolean dirty));
  434.  
  435.  
  436.  
  437. extern void OfsBlockFind _ARGS_((int hashSeed, Ofs_Domain *ofsPtr, 
  438.         int nearBlock, Boolean allocate, int *blockNumPtr, 
  439.         unsigned char **bitmapPtrPtr));
  440. extern void OfsBlockFree _ARGS_((Ofs_Domain *ofsPtr, int blockNum));
  441. extern void OfsFragFind _ARGS_((int hashSeed, Ofs_Domain *ofsPtr, int numFrags,
  442.         int lastFragBlock, int lastFragOffset, int lastFragSize, 
  443.         int *newFragBlockPtr, int *newFragOffsetPtr));
  444. extern void OfsFragFree _ARGS_((Ofs_Domain *ofsPtr, int numFrags, 
  445.         int fragBlock, int fragOffset));
  446.  
  447. /*
  448.  * Cache backend routines. 
  449.  */
  450. extern ReturnStatus Ofs_BlockAllocate _ARGS_((Fsdm_Domain *domainPtr, 
  451.         Fsio_FileIOHandle *handlePtr, int offset, int numBytes, 
  452.         int flags, int *blockAddrPtr, Boolean *newBlockPtr));
  453. extern ReturnStatus Ofs_FileBlockWrite _ARGS_((Fsdm_Domain *domainPtr, 
  454.         Fsio_FileIOHandle *handlePtr, Fscache_Block *blockPtr));
  455. extern ReturnStatus Ofs_FileBlockRead _ARGS_((Fsdm_Domain *domainPtr, 
  456.         Fsio_FileIOHandle *handlePtr, Fscache_Block *blockPtr));
  457. extern Boolean Ofs_StartWriteBack _ARGS_((Fscache_Backend *backendPtr));
  458. extern void Ofs_ReallocBlock _ARGS_((ClientData data, 
  459.         Proc_CallInfo *callInfoPtr));
  460.  
  461.  
  462. /*
  463.  * Routines for attaching/detaching disk.
  464.  */
  465. extern ReturnStatus Ofs_AttachDisk _ARGS_((Fs_Device *devicePtr, 
  466.         char *localName, int flags, int *domainNumPtr));
  467. extern ReturnStatus Ofs_DetachDisk _ARGS_((Fsdm_Domain *domainPtr));
  468. /*
  469.  * Routines to manipulate domains.
  470.  */
  471. extern ReturnStatus Ofs_DomainInfo _ARGS_((Fsdm_Domain *domainPtr, 
  472.         Fs_DomainInfo *domainInfoPtr));
  473. extern ReturnStatus Ofs_DomainWriteBack _ARGS_((Fsdm_Domain *domainPtr, 
  474.         Boolean shutdown));
  475. extern ReturnStatus Ofs_RereadSummaryInfo _ARGS_((Fsdm_Domain *domainPtr));
  476. extern ReturnStatus OfsDeviceBlockIO _ARGS_((Ofs_Domain *ofsPtr, 
  477.         int readWriteFlag, int fragNumber, int numFrags, 
  478.         Address buffer));
  479. extern ReturnStatus OfsWriteBackSummaryInfo _ARGS_((Ofs_Domain *ofsPtr));
  480. extern ReturnStatus OfsWriteBackDataBlockBitmap _ARGS_((Ofs_Domain *ofsPtr));
  481. extern ReturnStatus OfsWriteBackFileDescBitmap _ARGS_((Ofs_Domain *ofsPtr));
  482.  
  483. /*
  484.  * Directory change calls.
  485.  */
  486. extern ClientData Ofs_DirOpStart _ARGS_((Fsdm_Domain *domainPtr, int opFlags,
  487.         char *name, int nameLen, int fileNumber, 
  488.         Fsdm_FileDescriptor *fileDescPtr, int dirFileNumber, 
  489.         int dirOffset, Fsdm_FileDescriptor *dirFileDescPtr));
  490. extern void Ofs_DirOpEnd _ARGS_((Fsdm_Domain *domainPtr, ClientData clientData,
  491.     ReturnStatus status, int opFlags, char *name, int nameLen,
  492.     int fileNumber, Fsdm_FileDescriptor *fileDescPtr, int dirFileNumber,
  493.     int dirOffset, Fsdm_FileDescriptor *dirFileDescPtr));
  494. /*
  495.  * Miscellaneous
  496.  */
  497. extern void Ofs_Init _ARGS_((void));
  498. extern ReturnStatus OfsIOInit _ARGS_((Fsdm_Domain *domainPtr));
  499. extern ReturnStatus OfsFileDescAllocInit _ARGS_((Ofs_Domain *ofsPtr));
  500. extern ReturnStatus OfsBlockAllocInit _ARGS_((Ofs_Domain *ofsPtr));
  501. extern int OfsBlocksToSectors _ARGS_((int fragNumber, Ofs_Geometry *geoPtr));
  502. extern ReturnStatus OfsVerifyBlockWrite _ARGS_((Ofs_Domain *ofsPtr, 
  503.                 Fscache_Block *blockPtr));
  504.  
  505. #endif /* KERNEL */
  506.  
  507. #endif /* _OFS */
  508.